home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / glammar / gg13.c < prev    next >
C/C++ Source or Header  |  1991-01-21  |  12KB  |  443 lines
  1. /*
  2.  
  3.     This file is a part of the GLAMMAR source distribution 
  4.     and therefore subjected to the copy notice below. 
  5.     
  6.     Copyright (C) 1989,1990  Eric Voss, ericv@cs.kun.nl 
  7.  
  8.     This program is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation version 1
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. /* file     general transactions on the data structure 
  23.    * print back in glammar source
  24.    * make a contex free grammar  : stripe affixes
  25.    * make an identity grammar   : add some affixes
  26.    * make a parse tree grammar   : add even more affixes
  27. */
  28.  
  29. #include "gg1.h"
  30. #include "gg2.h"
  31. static int do_trick = false;
  32. printtree()
  33. {
  34.    int             rule_item;
  35.    if (do_trick) 
  36.        trick();
  37.    for (rule_item = root; rule_item != laststdpred; rule_item =
  38.        BROTHER(rule_item))
  39.       print_rule(rule_item);
  40.    for (rule_item = lastmetarule; rule_item != nil; rule_item =
  41.        BROTHER(rule_item)) 
  42.       print_meta(rule_item);
  43.    for (rule_item = first_lattice; rule_item != nil; rule_item =
  44.        BROTHER(rule_item))
  45.       print_lattice (rule_item);
  46.  
  47. }
  48.  
  49. print_meta(rule)
  50. {
  51.    int             term, alt;
  52.  
  53.    printf("%s :: ", REPR(rule));
  54.  
  55.    switch (NODENAME(rule)) {
  56.    case meta_prod_rule:
  57.    case One:
  58.             print_meta_terms(SON(rule));
  59.             break;
  60.    case Mult:
  61.     
  62.       printf("\n\t");
  63.       for (alt = SON(rule); alt != nil; alt = BROTHER(alt))  {
  64.             print_meta_terms(SON(alt));
  65.             if (BROTHER(alt) != nil)
  66.                printf(";\n\t");
  67.       }
  68.       break;
  69.    default: 
  70.         printf("unknown type\n");
  71.    }
  72.    printf(".\n\n");
  73. }
  74.  
  75. print_meta_terms(term_item)
  76. int          term_item;
  77. {
  78.    int             fact_item;
  79.    for (; term_item != nil; term_item = BROTHER(term_item))  {
  80.    if ((NODENAME(term_item))  == supernt) {
  81.       int             lhs = DEF(term_item);
  82.       printf(" @  %s", REPR(lhs));
  83.       printaffixtree(AFFIXTREE(term_item));
  84.    } else if (NODENAME(term_item) == factor)
  85.       for (fact_item = SON(term_item); fact_item != nil; fact_item =
  86.           BROTHER(fact_item)) {
  87.          if (NODENAME(fact_item) == affixnt)
  88.             printf("%s", REPR(fact_item));
  89.          else
  90.             printf("\"%s\"", REPR(fact_item));
  91.          if (BROTHER(fact_item) != nil)
  92.             printf("*");
  93.       }
  94.    else if (NODENAME(term_item) == affixnt)
  95.       printf("%s", REPR(term_item));
  96.    else
  97.       printf("\"%s\"", REPR(term_item));
  98.    if (BROTHER(term_item) != nil)
  99.       printf("+");
  100.    }
  101. }
  102.  
  103. print_lattice(rule)
  104. int             rule;
  105. {
  106.    int            mem;
  107.    printf ("# Lattice %d  @%x\n%s :: {}\n\t" ,DEF(rule),NODENAME(rule),
  108.                                               REPR(rule));
  109.    for (mem = SON(rule);mem != nil;mem = BROTHER(mem)) {
  110.      printf ("%s"  ,REPR(mem));
  111.      if (BROTHER(mem) != nil)
  112.        printf (";\t# @%x\n\t",NODENAME(mem));
  113.      else   printf (".\t# @%x\n\n",NODENAME(mem));
  114.    }
  115. }
  116.      
  117.  
  118. print_rule(rule_item)
  119. int             rule_item;
  120. {
  121.    int             alt_item, mem_item;
  122.       if (MARKED(rule_item,emptyrule))
  123.          printf("  # Empty\n");
  124.       if (MARKED(rule_item,notemptyrule))
  125.          printf("  # Not empty\n");
  126.       if (MARKED(rule_item,nondeterministic))
  127.          printf("  # Nondeterministic\n");
  128.       if (MARKED(rule_item,deterministic))
  129.          printf("  # Deterministic\n");
  130.    for (alt_item = SON(rule_item);alt_item != nil;alt_item = BROTHER(alt_item)){
  131.       print_lhs(rule_item,alt_item);
  132.       if (SON(alt_item) != nil)  {
  133.        if (BROTHER(SON(alt_item)) != nil)
  134.              printf("\n");
  135.        print_rhs(SON(alt_item));
  136.       }
  137.       if (BROTHER(alt_item) != nil)
  138.          printf(";\n");
  139.    }
  140.    printf(".\n\n");
  141. }
  142.  
  143. print_lhs(rule_item,alt_item) 
  144. int rule_item,alt_item;
  145. {
  146.       printf("%s", REPR(rule_item));
  147.       printaffixtree(AFFIXDEF(alt_item));
  148.       if (MARKED(rule_item,external))
  149.          printf("=      ");
  150.       else printf(":    ");
  151.  
  152. }
  153.  
  154. print_rhs(mem_item) 
  155. int mem_item;
  156. {
  157.       for (; mem_item != nil; mem_item = BROTHER(mem_item)) {
  158.          if (LKH(mem_item))
  159.             printf("?");
  160.          if (TERMINAL(mem_item)) {
  161.             if (STRING(mem_item))
  162.                printf("    \"%s\"", REPR(mem_item));
  163.             else {
  164.                if (COMPLEMENT(mem_item))
  165.                   printf("    ^");
  166.                else 
  167.                   printf("     ");
  168.                if (EXCLAMATIONSTARCHOICE(mem_item))
  169.                   printf("!%s! * ", REPR(mem_item));
  170.                else if (EXCLAMATIONPLUSCHOICE(mem_item))
  171.                   printf("!%s! + ", REPR(mem_item));
  172.                else
  173.                   printf("!%s!  ", REPR(mem_item));
  174.                printaffixtree(AFFIXTREE(mem_item));
  175.             }
  176.          } else {
  177.             int             lhs = DEF(mem_item);
  178.  
  179.             printf("    %s", REPR(lhs));
  180.             printaffixtree(AFFIXTREE(mem_item));
  181.          }
  182.          if (BROTHER(mem_item) != nil)
  183.             printf(",\n");
  184.       }
  185. }
  186.  
  187. printaffixtree(tree)
  188. int             tree;
  189. {
  190.    int             term_item,
  191.    fact_item;
  192.  
  193.    if (tree == nil)
  194.       return;
  195.    printf("(");
  196.    for (; tree != nil; tree = BROTHER(tree)) {
  197.       if ((NODENAME(tree) == inherited) && (DEF(tree) != -1)) {
  198.         if (MARKED_ADP(tree,affix_directed_parsing) )
  199.          printf("#ADP#");
  200.         if (MARKED_ADP(tree,no_affix_directed_parsing) )
  201.          printf("#NO_ADP#");
  202.       }
  203.       if (NODENAME(tree) == inherited)
  204.          printf(">");
  205.       if (LATTICE(tree))
  206.          printf("%s",REPR(SON(tree)));
  207.       else {
  208.       for (term_item = SON(tree); term_item != nil; term_item =
  209.           BROTHER(term_item)) {
  210.          if (NODENAME(term_item) == factor)
  211.             for (fact_item = SON(term_item); fact_item !=
  212.                 nil; fact_item =
  213.                 BROTHER(fact_item)) {
  214.                if (NODENAME(fact_item) == affixnt)
  215.                   printf("%s", REPR(fact_item));
  216.                else
  217.                   printf("\"%s\"", REPR(fact_item));
  218.                if (BROTHER(fact_item) != nil)
  219.                   printf("^");
  220.             }
  221.          else if (NODENAME(term_item) == affixnt)
  222.             printf("%s", REPR(term_item));
  223.          else if (NODENAME(term_item) == metaffix)
  224.             printf("%s", REPR(term_item));
  225.          else if (NODENAME(term_item) == superaffix)
  226.             printf("@%s", REPR(term_item));
  227.          else
  228.             printf("\"%s\"", REPR(term_item));
  229.          if (BROTHER(term_item) != nil)
  230.             printf("+");
  231.       }
  232.       if (NODENAME(tree) == derived)
  233.          printf(">");
  234.       }
  235.       if (BROTHER(tree) != nil)
  236.          printf(",");
  237.    }
  238.    printf(")");
  239. }
  240.  
  241. print_cfg_tree()
  242. {
  243.    int             rule_item;
  244.    for (rule_item = root; rule_item != laststdpred; rule_item =
  245.        BROTHER(rule_item))
  246.       print_cfg_rule(rule_item);
  247.  
  248.    for (rule_item = first_lattice; rule_item != nil; rule_item =
  249.        BROTHER(rule_item)) 
  250.         print_lattice (rule_item);
  251.  
  252. }
  253.  
  254. print_cfg_rule(rule_item)
  255. int             rule_item;
  256. {
  257.    int             alt_item, mem_item;
  258.    for (alt_item = SON(rule_item);alt_item != nil;alt_item = BROTHER(alt_item)){
  259.       print_cfg_lhs(rule_item,alt_item);
  260.       if (SON(alt_item) != nil)  {
  261.        if (BROTHER(SON(alt_item)) != nil)
  262.              printf("\n");
  263.        print_cfg_rhs(SON(alt_item));
  264.       }
  265.       if (BROTHER(alt_item) != nil)
  266.          printf(";\n");
  267.    }
  268.    printf(".\n\n");
  269. }
  270.  
  271. print_cfg_lhs(rule_item,alt_item) 
  272. int rule_item,alt_item;
  273. {
  274.       printf("%s", REPR(rule_item));
  275.       print_lattice_tree(AFFIXDEF(alt_item));
  276.       if (MARKED(rule_item,external))
  277.          printf("=      ");
  278.       else printf(":    ");
  279.  
  280. }
  281.  
  282. print_cfg_rhs(mem_item) 
  283. int mem_item;
  284. {
  285.       for (; mem_item != nil; mem_item = BROTHER(mem_item)) {
  286.          if (LKH(mem_item))
  287.             printf("?");
  288.          if (TERMINAL(mem_item)) {
  289.             if (STRING(mem_item))
  290.                printf("    \"%s\"", REPR(mem_item));
  291.             else {
  292.                if (COMPLEMENT(mem_item))
  293.                   printf("    ^");
  294.                else 
  295.                   printf("     ");
  296.                if (EXCLAMATIONSTARCHOICE(mem_item))
  297.                   printf("!%s! * ", REPR(mem_item));
  298.                else if (EXCLAMATIONPLUSCHOICE(mem_item))
  299.                   printf("!%s! + ", REPR(mem_item));
  300.                else
  301.                   printf("!%s!  ", REPR(mem_item));
  302.                print_lattice_tree(AFFIXTREE(mem_item));
  303.             }
  304.          } else {
  305.             int             lhs = DEF(mem_item);
  306.  
  307.             printf("    %s", REPR(lhs));
  308.             print_lattice_tree(AFFIXTREE(mem_item));
  309.          }
  310.          if (BROTHER(mem_item) != nil)
  311.             printf(",\n");
  312.       }
  313. }
  314.  
  315. print_lattice_tree(tree)
  316. int             tree;
  317. {
  318.    int             afx = tree;
  319.  
  320.    if (tree == nil)
  321.       return;
  322.    if (!lattice_in_tree(tree)) return ;
  323.  
  324.    printf("(");
  325.    for (; tree != nil; tree = BROTHER(tree)) 
  326.       if (LATTICE(tree)) { 
  327.             printf("%s", REPR(SON(tree)));
  328.             if (lattice_in_tree(BROTHER(tree)))
  329.                printf(",");
  330.       }
  331.    printf(")");
  332. }
  333.  
  334. lattice_in_tree(afx) 
  335. int afx;
  336. {   
  337.    for (; afx != nil; afx = BROTHER(afx)) 
  338.        if(LATTICE(afx) )
  339.          return true;
  340.    return false;
  341. }
  342. parse_tree() {
  343.   register int ag,mem, afx,alt,rule;
  344.   for (rule = root; rule != laststdpred; rule = BROTHER(rule))
  345.     for (alt = SON (rule) ; alt != nil; alt = BROTHER (alt)) {
  346.       brother = nil;
  347.          newnode(affixtm,brother,nil,")\\n"); 
  348.          add_parse_tree_term_lhs(SON(alt));
  349.          newnode(affixtm,brother,nil,REPR(rule)); 
  350.          newnode(affixtm,brother,nil,"("); 
  351.          newnode(derived,AFFIXDEF(alt),brother,"");
  352.          AFFIXDEF(alt) = brother;
  353.       for (mem = SON (alt) ; mem != nil; mem = BROTHER (mem))
  354.          if (!TERMINAL(mem))   {
  355.             newnode(affixnt,nil,nil,REPR(mem));
  356.             newnode(derived,AFFIXTREE(mem),brother,"");
  357.             AFFIXTREE(mem) = brother;
  358.          }
  359.    }
  360.          
  361. }
  362.  
  363. add_parse_tree_term_lhs(mem) 
  364. int mem;
  365. {
  366.     if (mem == nil)
  367.        return;
  368.     add_parse_tree_term_lhs(BROTHER(mem));
  369.     add_parse_tree_term(mem);
  370. }
  371.  
  372.       
  373. add_parse_tree_term(mem)
  374. {
  375.   if (STRING(mem)) { 
  376.      if (BROTHER(mem) != nil)
  377.        newnode(affixtm,brother,nil,","); 
  378.      newnode(affixtm,brother,nil,REPR(mem));
  379.    }
  380.    else if (TERMINAL(mem)) { 
  381.      if (BROTHER(mem) != nil)
  382.        newnode(affixtm,brother,nil,","); 
  383.      newnode(affixnt,brother,nil,REPR(SON(AFFIXTREE(mem))));
  384.    } 
  385.    else  {
  386.      if (BROTHER(mem) != nil)
  387.        newnode(affixtm,brother,nil,","); 
  388.      newnode(affixnt,brother,nil,REPR(mem)); 
  389.    }
  390. }
  391.  
  392. id_tree() {
  393.   register int ag,mem, afx,alt,rule;
  394.   for (rule = root; rule != laststdpred; rule = BROTHER(rule))
  395.     for (alt = SON (rule) ; alt != nil; alt = BROTHER (alt)) {
  396.       brother = nil;
  397.          add_id_tree_term_lhs(SON(alt));
  398.          newnode(derived,AFFIXDEF(alt),brother,"");
  399.          AFFIXDEF(alt) = brother;
  400.       for (mem = SON (alt) ; mem != nil; mem = BROTHER (mem))
  401.          if ((!TERMINAL(mem)) &&  (mem >laststdpred))   {
  402.             newnode(affixnt,nil,nil,REPR(mem));
  403.             newnode(derived,AFFIXTREE(mem),brother,"");
  404.             AFFIXTREE(mem) = brother;
  405.          }
  406.    }
  407. }
  408.  
  409. add_id_tree_term_lhs(mem) 
  410. int mem;
  411. {
  412.     if (mem == nil)
  413.        return;
  414.     add_id_tree_term_lhs(BROTHER(mem));
  415.     if (mem > laststdpred)
  416.        add_id_tree_term(mem);
  417. }
  418.  
  419.       
  420. add_id_tree_term(mem)
  421. {
  422.   if (STRING(mem))  
  423.      newnode(affixtm,brother,nil,REPR(mem));
  424.   else if (TERMINAL(mem)) 
  425.      newnode(affixnt,brother,nil,REPR(SON(AFFIXTREE(mem))));
  426.   else  
  427.      newnode(affixnt,brother,nil,REPR(mem)); 
  428.    
  429. }
  430. trick() {
  431.      int rule,x;
  432.      for (rule = root; rule != laststdpred; rule = BROTHER(rule)) {
  433.       x = SON(rule); 
  434.       if (x == nil) continue; 
  435.       x = AFFIXDEF(x); 
  436.       if (x == nil) continue; 
  437.       x = SON(x); 
  438.       if (x == nil) continue; 
  439.       if (NODENAME(x) == affixtm)
  440.           REPR(rule) = REPR(x)+1; 
  441.      }
  442. }
  443.